/*
 * NOTICE: THE FILE HAS BEEN MODIFIED TO SUIT THE NEEDS OF THE PROJECT.
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.robobinding.util;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;

/**
 * Migrated some of methods from
 * {@link org.apache.commons.lang3.reflect.ConstructorUtils}.
 * 
 * @since 1.0
 * @version $Revision: 1.0 $
 * @author Cheng Wei
 */
public class ConstructorUtils {

	private ConstructorUtils() {
	}

	/**
	 * <p>
	 * Returns a new instance of the specified class inferring the right
	 * constructor from the types of the arguments.
	 * </p>
	 * 
	 * <p>
	 * This locates and calls a constructor. The constructor signature must
	 * match the argument types by assignment compatibility.
	 * </p>
	 * 
	 * @param <T>
	 *            the type to be constructed
	 * @param cls
	 *            the class to be constructed, not null
	 * @param args
	 *            the array of arguments, null treated as empty
	 * @return new instance of <code>cls</code>, not null
	 * 
	 * @throws NoSuchMethodException
	 *             if a matching constructor cannot be found
	 * @throws IllegalAccessException
	 *             if invocation is not permitted by security
	 * @throws InvocationTargetException
	 *             if an error occurs on invocation
	 * @throws InstantiationException
	 *             if an error occurs on instantiation
	 * @see #invokeConstructor(java.lang.Class, java.lang.Object[],
	 *      java.lang.Class[])
	 */
	public static <T> T invokeConstructor(final Class<T> cls, Object... args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
			InstantiationException {
		if (args == null) {
			args = ArrayUtils.EMPTY_OBJECT_ARRAY;
		}
		final Class<?>[] parameterTypes = ClassUtils.toClass(args);
		return invokeConstructor(cls, args, parameterTypes);
	}

	/**
	 * <p>
	 * Returns a new instance of the specified class choosing the right
	 * constructor from the list of parameter types.
	 * </p>
	 * 
	 * <p>
	 * This locates and calls a constructor. The constructor signature must
	 * match the parameter types by assignment compatibility.
	 * </p>
	 * 
	 * @param <T>
	 *            the type to be constructed
	 * @param cls
	 *            the class to be constructed, not null
	 * @param args
	 *            the array of arguments, null treated as empty
	 * @param parameterTypes
	 *            the array of parameter types, null treated as empty
	 * @return new instance of <code>cls</code>, not null
	 * 
	 * @throws NoSuchMethodException
	 *             if a matching constructor cannot be found
	 * @throws IllegalAccessException
	 *             if invocation is not permitted by security
	 * @throws InvocationTargetException
	 *             if an error occurs on invocation
	 * @throws InstantiationException
	 *             if an error occurs on instantiation
	 * @see Constructor#newInstance
	 */
	public static <T> T invokeConstructor(final Class<T> cls, Object[] args, Class<?>[] parameterTypes) throws NoSuchMethodException, IllegalAccessException,
			InvocationTargetException, InstantiationException {
		if (parameterTypes == null) {
			parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
		}
		if (args == null) {
			args = ArrayUtils.EMPTY_OBJECT_ARRAY;
		}
		final Constructor<T> ctor = getMatchingAccessibleConstructor(cls, parameterTypes);
		if (ctor == null) {
			throw new NoSuchMethodException("No such accessible constructor on object: " + cls.getName());
		}
		return ctor.newInstance(args);
	}

	// -----------------------------------------------------------------------
	/**
	 * <p>
	 * Finds a constructor given a class and signature, checking accessibility.
	 * </p>
	 * 
	 * <p>
	 * This finds the constructor and ensures that it is accessible. The
	 * constructor signature must match the parameter types exactly.
	 * </p>
	 * 
	 * @param <T>
	 *            the constructor type
	 * @param cls
	 *            the class to find a constructor for, not null
	 * @param parameterTypes
	 *            the array of parameter types, null treated as empty
	 * @return the constructor, null if no matching accessible constructor found
	 * @see Class#getConstructor
	 * @see #getAccessibleConstructor(java.lang.reflect.Constructor)
	 */
	public static <T> Constructor<T> getAccessibleConstructor(final Class<T> cls, final Class<?>... parameterTypes) {
		try {
			return getAccessibleConstructor(cls.getConstructor(parameterTypes));
		} catch (final NoSuchMethodException e) {
			return null;
		}
	}

	/**
	 * <p>
	 * Checks if the specified constructor is accessible.
	 * </p>
	 * 
	 * <p>
	 * This simply ensures that the constructor is accessible.
	 * </p>
	 * 
	 * @param <T>
	 *            the constructor type
	 * @param ctor
	 *            the prototype constructor object, not null
	 * @return the constructor, null if no matching accessible constructor found
	 * @see java.lang.SecurityManager
	 */
	public static <T> Constructor<T> getAccessibleConstructor(final Constructor<T> ctor) {
		return MemberUtils.isAccessible(ctor) && Modifier.isPublic(ctor.getDeclaringClass().getModifiers()) ? ctor : null;
	}

	/**
	 * <p>
	 * Finds an accessible constructor with compatible parameters.
	 * </p>
	 * 
	 * <p>
	 * This checks all the constructor and finds one with compatible parameters
	 * This requires that every parameter is assignable from the given parameter
	 * types. This is a more flexible search than the normal exact matching
	 * algorithm.
	 * </p>
	 * 
	 * <p>
	 * First it checks if there is a constructor matching the exact signature.
	 * If not then all the constructors of the class are checked to see if their
	 * signatures are assignment compatible with the parameter types. The first
	 * assignment compatible matching constructor is returned.
	 * </p>
	 * 
	 * @param <T>
	 *            the constructor type
	 * @param cls
	 *            the class to find a constructor for, not null
	 * @param parameterTypes
	 *            find method with compatible parameters
	 * @return the constructor, null if no matching accessible constructor found
	 */
	public static <T> Constructor<T> getMatchingAccessibleConstructor(final Class<T> cls, final Class<?>... parameterTypes) {
		// see if we can find the constructor directly
		// most of the time this works and it's much faster
		try {
			final Constructor<T> ctor = cls.getConstructor(parameterTypes);
			MemberUtils.setAccessibleWorkaround(ctor);
			return ctor;
		} catch (final NoSuchMethodException e) { // NOPMD - Swallow
		}
		Constructor<T> result = null;
		/*
		 * (1) Class.getConstructors() is documented to return Constructor<T> so
		 * as long as the array is not subsequently modified, everything's fine.
		 */
		final Constructor<?>[] ctors = cls.getConstructors();

		// return best match:
		for (Constructor<?> ctor : ctors) {
			// compare parameters
			if (ClassUtils.isAssignable(parameterTypes, ctor.getParameterTypes(), true)) {
				// get accessible version of constructor
				ctor = getAccessibleConstructor(ctor);
				if (ctor != null) {
					MemberUtils.setAccessibleWorkaround(ctor);
					if (result == null || MemberUtils.compareParameterTypes(ctor.getParameterTypes(), result.getParameterTypes(), parameterTypes) < 0) {
						// temporary variable for annotation, see comment above
						// (1)
						@SuppressWarnings("unchecked")
						final Constructor<T> constructor = (Constructor<T>) ctor;
						result = constructor;
					}
				}
			}
		}
		return result;
	}

}
